| spell_routines.inc v2.2 
| Originally Written by Rusty~ 
| Upkeep performed by A_Druid_00 
| [02-15-2006] By Crystane, reworked this to work without the exchange plugin for AFnuke.mac
| 
| Also includes FD fix that would cause an endless loop if you were hit by FD mid-cast by A_Druid_00 
| Features: 
| - Casts spells, clicks items, or uses AA abilities for you 
| - Allows back to back casting without waiting on spell gems to pop all the way up 
| - Will interrupt spell if target dies while casting. If on a mount, it will dismount and duck if the time left 
| is greater than 7 seconds, else it will move forward a bit to interrupt, then move you back 
| ** IMPORTANT: if you don't want to interrupt a spell while mounted, put this at the top of your macro: ** 
| ** /declare noInterrupt int outer 1 ** 
| - Allows you to use items in bags. Equips item, clicks it, then returns it to its previous location 
| - Lets you set how long you want to keep trying to cast the spell (defaults to 0) 
| If the spell is interrupted before the given time, it will recast, else it will return CAST_INTERRUPTED 
| - Lets you call a custom subroutine while waiting for spell to finish casting 
| Try to keep custom subroutines very small. A common use would be to interrupt the spell if a certain condition is true 
| - This file also includes a sub named Interrupt. You can call this to interrupt any spell you're casting instantly. 
| - You can also use the SwapItem sub included in this to swap items to certain slots 
| - Added EquipItem sub to easily equip items in your main Inventory slots. 
| - Note: if you don't want this to cast spells while you're invis, in your main macro have this at the top: 
| /declare noInvis int outer 1 
| This will make it return CAST_INVIS if you're invis 
| Below is a list of outer scope variables you can access in your macros: 
| refreshTime - How much time is left till you're done recovering from casting 
| castEndTime - How much time left till you're done casting the current spell... usable in custom spell Subs 
| spellNotHold - 1 if your last spell didn't take hold, 0 otherwise 
| spellRecastTime1-9 - How much time left till that spell is back up 
|================================================= ================================================== =================== 
| EquipItem: An easier way to equip items you have in bags ( useful for weapons or focus items ) 
| slot name is optional. If not given, it will equip it in the first possible spot 
| Usage: 
| /call EquipItem "item name|slotname" 
| Returns: "old item name|slotname" 
| Examples: 
| To Equip Sharp Ended Broken Lever when you have Serpent of Vindication equiped: 
| /call EquipItem "Sharp Ended Broken Lever" 
| It will return "Staff of Vindication|mainhand" 
| To reequip the original item, you can save the return in a variable, and then use it later like this: 
| /varset oldPrimary ${Macro.Return} 
| | ... do stuff here with your new item equiped 
| /call EquipItem ${oldPrimary} 
|================================================= ================================================== =================== 
| SwapItem: a subroutine which is used in the Cast sub itself. You don't need to do this to cast an item in a bag 
| but you can call it in your macro to SwapItems (such as weapons or focus items) 
| Usage: 
| /call SwapItem "item name" slotname 
| Examples: 
| To swap Darkblade of the Warlord to your main hand: 
| /call SwapItem "Darkblade of the Warlord" mainhand 
| To swap stat food in one bag with other food in another bag: 
| /call SwapItem "Bristlebanes Party Platter" ${FindItem[halas 10lb meat pie].InvSlot} 
|================================================= ================================================== =================== 
| Cast: the main subroutine that casts spells or items for you 
| Usage: 
| /call Cast "spellname|itemname|AAname|AA#" [item|alt|gem#] [give up time][s|m] [custom subroutine name] [Number of resist recasts] 
| Examples: 
| To cast Howl of Tashan and mem it in slot 3 if not memmed: 
| /call Cast "Howl of Tashan" gem3 
| To cast Arcane Rune and keep trying for 7 seconds, in case of interrupts. 
| /call Cast "Arcane Rune" gem5 7s 
| To click Grim Aura earring that's in a bag: 
| /call Cast "Shrunken Goblin Skull Earring" item 
| To use AA ability Eldritch Rune: 
| /call Cast "Eldritch Rune" alt 
| or 
| /call Cast "173" alt 
| To call a subroutine that interrupts CH if target gets healed before it lands: 
| /call Cast "Complete Healing" gem1 0 CheckHP 
| Then in your macro have somewhere: 
| Sub CheckHP 
| /if ( ${Target.PctHPs}>=80 ) /call Interrupt 
| /return 
| Returns these values: 
|----------------------+----------------------------------------------------------------------+ 
| CAST_CANCELLED | Spell was cancelled by ducking (either manually or because mob died) | 
| CAST_CANNOTSEE | You can't see your target | 
| CAST_IMMUNE | Target is immune to this spell | 
| CAST_INTERRUPTED | Casting was interrupted and exceeded the given time limit | 
| CAST_INVIS | You were invis, and noInvis is set to true | 
| CAST_NOTARGET | You don't have a target selected for this spell | 
| CAST_NOTMEMMED | Spell is not memmed and you gem to mem was not specified | 
| CAST_NOTREADY | AA ability or spell is not ready yet | 
| CAST_OUTOFMANA | You don't have enough mana for this spell! | 
| CAST_OUTOFRANGE | Target is out of range | 
| CAST_RESISTED | Your spell was resisted! | 
| CAST_SUCCESS | Your spell was cast successfully! (yay) | 
| CAST_UNKNOWNSPELL | Spell/Item/Ability was not found | 
|----------------------+----------------------------------------------------------------------+ 
#event BeginCast "You begin casting#*#" 
#event Collapse "Your gate is too unstable, and collapses.#*#" 
#event FDFail "#1# has fallen to the ground.#*#" 
#event Fizzle "Your spell fizzles#*#" 
#event Immune "Your target is immune to changes in its attack speed#*#" 
#event Immune "Your target is immune to changes in its run speed#*#" 
#event Immune "Your target cannot be mesmerized#*#" 
#event Interrupt "Your casting has been interrupted#*#" 
#event Interrupt "Your spell is interrupted#*#" 
#event NoHold "Your spell did not take hold#*#" 
#event NoHold "Your spell would not have taken hold#*#" 
#event NoLOS "You cannot see your target.#*#" 
#event NoTarget "You must first select a target for this spell!#*#" 
#event NotReady "Spell recast time not yet met.#*#" 
#event OutOfMana "Insufficient Mana to cast this spell!#*#" 
#event OutOfRange "Your target is out of range, get closer!#*#" 
#event Recover "You haven't recovered yet...#*#" 
#event Recover "Spell recovery time not yet met#*#" 
#event Resisted "Your target resisted the #1# spell#*#" 
#event Resisted2 "You resist the #1# spell#*#" 
#event Standing "You must be standing to cast a spell#*#" 
#event Stunned "You are stunned#*#" 
#event Stunned "You can't cast spells while stunned!#*#" 
#event Stunned "You *CANNOT* cast spells, you have been silenced!#*#" 

Sub Cast(spellName,spellType,giveUpValue,mySub,int ResistTotal) 
/declare castTime float local 

/if (${Defined[castReturn]}) /varset castReturn CAST_CANCELLED 
/if (${Me.Invis} && ${noInvis}) /return CAST_INVIS
/if (${spellType.Equal[item]}) { 
/if (!${FindItem[${spellName}].InvSlot}) /return CAST_UNKNOWNSPELL 
/varset castTime ${FindItem[${spellName}].CastTime} 
} else /if (${spellType.Equal[alt]}) { 
/if (!${Me.AltAbilityReady[${spellName}]}) /return CAST_NOTREADY 
/varset castTime ${AltAbility[${spellName}].Spell.CastTime} 
} else { 
/if (!${Me.Book[${spellName}]}) /return CAST_UNKNOWNSPELL 
/declare spellID int local 
/varset castTime ${Spell[${spellName}].CastTime} 
/varset spellID ${Me.Book[${Me.Book[${spellName}]}].ID} 
/if (${Me.CurrentMana}<${Spell[${spellID}].Mana}) /return CAST_OUTOFMANA 
} 
/if (${castTime}>0.1 && ${Stick.Status.Equal[ON]}) /stick pause 
/if (!${Defined[spellType]}) /declare spellType string local spell 
/if (!${Defined[spellRecastTime1]}) { 
/if (!${Defined[noInterrupt]}) /declare noInterrupt int outer 0 
/declare ResistCounter int outer 
/declare moveBack bool outer false 
/declare selfResist int outer 
/declare selfResistSpell string outer 
/declare giveUpTimer timer outer 
/declare castEndTime timer outer 
/declare refreshTime timer outer 
/declare itemRefreshTime float outer 
/declare i int local 
/declare castReturn string outer 
/declare spellNotHold int outer 
/delay 5 
/for i 1 to 9 
/declare spellRecastTime${i} timer outer 
/if (${Me.SpellReady[${i}]}) { 
/varset spellRecastTime${i} 0 
} else { 
/varcalc spellRecastTime${i} 10*${Me.Gem[${i}].RecastTime} 
} 
/next i 
} 
/if (${Defined[giveUpValue]}) /varset giveUpTimer ${giveUpValue} 
/if (${Defined[ResistTotal]}) /varset ResistCounter ${ResistTotal} 
/varset spellNotHold 0 
/varset selfResist 0 
:wait_for_stop 
/if (${Me.Casting.ID} || (${Me.Moving} && ${castTime}>0.1)) { 
/if (${Bool[${mySub}]}) /call ${mySub} 
/goto :wait_for_stop 
} 
/if (${Window[SpellBookWnd].Open}) /keypress spellbook 
/if (${Me.Ducking}) /keypress duck 
/call DoCastingEvents 
/varset castReturn X 
/if (${spellType.Equal[item]}) /call ItemCast "${spellName}" "${mySub}" 
/if (${spellType.Equal[alt]}) /call AltCast "${spellName}" "${mySub}" 
/if (${spellType.NotEqual[item]} && ${spellType.NotEqual[alt]}) /call SpellCast "${spellType}" "${spellName}" "${mySub}" "${spellID}" "${giveUpValue}" 
/if (${Stick.Status.Equal[PAUSED]}) /squelch /stick unpause 
/varset giveUpTimer 0 
/varset ResistCounter 0 

/return ${castReturn} 

Sub SpellCast(spellType,spellName,mySub,int spellID,giveUpValue) 
:cast_spell 
/if (!${Me.Gem[${spellName}]}) { 
/if (${Cursor.ID}) /call ClearCursor 
/if (${spellType.Left[3].Equal[gem]}) { 
/memspell ${spellType.Right[1]} "${spellName}" 
} else { 
/return CAST_NOTMEMMED 
} 
/delay 6s ${Me.Gem[${spellName}]} 
/if (${Me.Gem[${spellName}]}) /varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellID}].RecastTime} 
/if (!${Me.Gem[${spellName}]}) /return CAST_INTERRUPTED 
:wait_for_mem 
/delay 15s ${Me.SpellReady[${spellName}]} 
/if (!${Me.SpellReady[${spellName}]}) { 
/if (${giveUpTimer}) /goto :wait_for_mem 
/return CAST_NOTREADY 
} 
} 

/varset spellType spell 
/if (${spellName.Find[illusion: ]} && ${Me.AltAbilityReady[project illusion]}) /call Cast "project illusion" alt 
/varset giveUpTimer ${giveUpValue} 
/declare recoverWaitTime timer local 30 
:cast_spell_loop 
/if (!${Me.SpellReady[${spellName}]} && (${spellRecastTime${Me.Gem[${spellName}]}}<${giveUpTimer} || ${refreshTime}>0 || ${castReturn.Equal[CAST_RESISTED]})) { 
/if (${Bool[${mySub}]}) /call ${mySub} 
/goto :cast_spell_loop 
} else { 
/if (!${Me.SpellReady[${spellName}]} && !${castReturn.Equal[CAST_RESISTED]}) /return CAST_NOTREADY 
} 
/cast "${spellName}" 
/if (${Me.Casting.ID}) { 
/varset spellID ${Me.Casting.ID} 
/varcalc castEndTime ${Me.Casting.CastTime}*10 
/if (${castEndTime}<${Math.Calc[${Me.Casting.CastTime}*5]}) /varcalc castEndTime ${Me.Casting.CastTime}*5 
} 

/varset moveBack false 
/call WaitCast ${mySub} 
/if (${moveBack}) { 
/keypress back hold 
/delay 4 
/keypress back 
/delay 15 !${Me.Moving} 
} 

/if (${castReturn.Equal[CAST_CANCELLED]}) /return CAST_CANCELLED 
/call DoCastingEvents 
/if (!${castReturn.Equal[CAST_SUCCESS]}) { 
/if (${castReturn.Equal[CAST_RECOVER]}) { 
/if (!${recoverWaitTime}) { 
/varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellID}].RecastTime} 
/if (!${giveUpTimer}) /return CAST_NOTREADY 
} 
/goto :cast_spell_loop 
} 
/if (${castReturn.Equal[CAST_RESTART]} || ${castReturn.Equal[CAST_STUNNED]} || ${castReturn.Equal[CAST_FIZZLE]} || ${castReturn.Equal[CAST_COLLAPSE]} || (${castReturn.Equal[CAST_INTERRUPTED]} && ${giveUpTimer}) || (${castReturn.Equal[CAST_RESISTED]} && ${ResistCounter})) /goto :cast_spell_loop 
} 

/if (!${castReturn.Equal[CAST_CANNOTSEE]} && !${castReturn.Equal[CAST_OUTOFRANGE]} && !${castReturn.Equal[CAST_OUTOFMANA]} && !${castReturn.Equal[CAST_NOTARGET]} && !${castReturn.Equal[CAST_INTERRUPTED]}) { 
/varcalc refreshTime 10*${Spell[${spellID}].RecoveryTime} 
/varcalc spellRecastTime${Me.Gem[${spellName}]} 10*${Spell[${spellID}].RecastTime} 
} 
/return 

Sub ItemCast(spellName,mySub) 
/declare charges int local 
/declare oldItemName string local 
/declare slotName string local 
/declare swapItemBack bool local false 
:cast_item 
/if (${FindItem[${spellName}].InvSlot}>21) { 
/varset swapItemBack true 
/if (${FindItem[${spellName}].WornSlot[1]} && ${FindItem[${spellName}].EffectType.Find[worn]}) { 
/varset slotName ${FindItem[${spellName}].WornSlot[1].Name} 
} else /if (${FindItem[${spellName}].InvSlot}>29) { 
/varset slotName pack8 
} else { 
/varset slotName ${FindItem[${spellName}].InvSlot.Name} 
} 
/varset oldItemName ${InvSlot[${slotName}].Item.Name} 
/call SwapItem "${spellName}" ${slotName} 
} 
:wait_item_loop 
/if (${itemRefreshTime}>${MacroQuest.Running}) /goto :wait_item_loop 
/varset itemRefreshTime ${Math.Calc[${MacroQuest.Running}+000]} 
/varset charges ${FindItem[${spellName}].Charges} 
/cast item "${spellName}" 
/if (${Me.Casting.ID}) /varcalc castEndTime ${FindItem[${spellName}].CastTime}*10 
/if (${charges}) /delay 1s ${FindItem[${spellName}].Charges}!=${charges} 
/call WaitCast ${mySub} 
/if (${swapItemBack} && ${FindItem[${oldItemName}].ID}) /call SwapItem "${oldItemName}" ${slotName} 
/if (${castReturn.Equal[CAST_CANCELLED]}) /return CAST_CANCELLED 
/call DoCastingEvents 
/if (${castReturn.Equal[CAST_RESTART]} || ${castReturn.Equal[CAST_STUNNED]} || (${castReturn.Equal[CAST_INTERRUPTED]} && ${giveUpTimer}) || ${castReturn.Equal[CAST_COLLAPSE]} || (${castReturn.Equal[CAST_RESISTED]} && ${ResistCounter})) /goto :cast_item 
/return 

Sub AltCast(spellName,mySub) 
:cast_alt 
/alt activate ${AltAbility[${spellName}].ID} 
/if (${AltAbility[${spellName}].Spell.CastTime}>=0.5) /delay 1s ${Me.Casting.ID} 
/call WaitCast ${mySub} 
/if (${castReturn.Equal[CAST_CANCELLED]}) /return CAST_CANCELLED 
/call DoCastingEvents 
/if (${castReturn.Equal[CAST_RESTART]} || ${castReturn.Equal[CAST_STUNNED]} || (${castReturn.Equal[CAST_INTERRUPTED]} && ${giveUpTimer}) || (${castReturn.Equal[CAST_RESISTED]} && ${ResistCounter})) /goto :cast_alt 
/return 

Sub ClearCursor 
/declare i int local 
:auto_inv 
/if (${Cursor.ID}) { 
/if (${Cursor.Container}) { 
/for i 1 to 8 
/if (!${InvSlot[pack${i}].Item.Container}) { 
/nomodkey /itemnotify pack${i} leftmouseup 
} 
/next i 
} else { 
/autoinventory 
} 
/goto :auto_inv 
} 
/return 

Sub DoCastingEvents 
/doevents Recover 
/doevents BeginCast 
/doevents Fizzle 
/doevents Interrupt 
/doevents Standing 
/doevents FDFail 
/doevents OutOfRange 
/doevents OutOfMana 
/doevents NoLOS 
/doevents Resisted2 
/doevents Resisted 
/doevents Immune 
/doevents Stunned 
/doevents Collapse 
/doevents NoTarget 
/doevents NotReady 
/doevents NoHold 
/return 

Sub EquipItem(string WhatWhere) 
   /declare DestName string local 
   /declare ItemName string local ${String[${WhatWhere}].Arg[1,|]} 
   /declare SlotName string local ${String[${WhatWhere}].Arg[2,|]} 
   /if (${SlotName.Equal[NULL]}) /varset SlotName ${InvSlot[${FindItem[=${ItemName}].WornSlot[1]}].Name} 
   /if (${FindItem[=${ItemName}].InvSlot}<22 || !${FindItem[=${ItemName}].WornSlot[${SlotName}]}) /return 
   /if (!${InvSlot[${SlotName}].Item.Name.Equal[NULL]}) /varset DestName "${InvSlot[${SlotName}].Item.Name}|${SlotName}" 
   /call SwapItem "${ItemName}" "${SlotName}" 
/return ${DestName}

Sub Interrupt 
/if (${Me.Mount.ID}) /dismount 
/stopcast 
/if (${Defined[castReturn]}) /varset castReturn CAST_CANCELLED 
/return ${castReturn} 

Sub SwapItem(string itemName,string slotName) 
   /if ( ${InvSlot[${slotName}].Item.Name.Equal[${itemName}]} ) /return 
   /declare slotID int local 
   /declare oldSlotID int local 
   /declare oldItem string local 
   /declare i int local 
   /varset slotID ${InvSlot[${slotName}].ID}           | slotID = slot you're swapping item to 
   /varset oldSlotID ${FindItem[${itemName}].InvSlot.ID} | oldSlotID = slot the item was originally in 
   /varset oldItem ${InvSlot[${slotName}].Item.Name}     | oldItem = name of item in the slot you're swapping WITH 
   /if ( !${slotID} ) { 
      /echo Invalid slot name: ${slotName} 
      /return 
   } 
   /if ( !${oldSlotID} ) { 
      /echo Could not find item ${itemName} 
      /return 
   } 
:auto_inv 
   /if ( ${Cursor.ID} && !${Cursor.Name.Equal[${itemName}]} ) { 
      /if ( ${Cursor.Container} ) { 
         /for i 1 to 8 
            /if ( !${InvSlot[pack${i}].Item.Container} ) { 
               /nomodkey /itemnotify pack${i} leftmouseup 
            } 
         /next i 
      } else { 
         /autoinventory 
      } 
      /goto :auto_inv 
   } 
    

:pick_up_item 
 | if the item is in a bag and it's not open, then open it! 
   /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup 

 | if the slot you're putting it in is inside a bag and it's not open, then open it! 
   /if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup 

 | ok.. pick up the item now! 
   /squelch /nomodkey /shiftkey /itemnotify ${InvSlot[${oldSlotID}]} leftmouseup 

 | if item isn't on your cursor, try again! 
   /if ( !${Cursor.Name.Equal[${itemName}]} ) { 
      /if ( ${Cursor.ID} && !${Cursor.Container} ) /autoinventory 
      /goto :pick_up_item 
   } 
:exchange_items 
   /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup 
   /if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup 

 | put the item in the new slot, and pick up whatever item was there 
   /squelch /nomodkey /shiftkey /itemnotify ${slotID} leftmouseup 

 | if it didnt get exchanged, try again! 
   /if ( ${Cursor.ID} && !${Cursor.Name.Equal[${oldItem}]} && !${Cursor.Name.Equal[${itemName}]} && !${Cursor.Container} ) /autoinventory 
   /if ( !${InvSlot[${slotID}].Item.Name.Equal[${itemName}]} ) /goto :exchange_items 
:drop_item 
   /if ( !${Cursor.Container} || ( ${InvSlot[${oldSlotID}]}<30 && ${InvSlot[${oldSlotID}]}>=22 ) ) { 
      /if ( ${InvSlot[${oldSlotID}].Pack} && !${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup 
      /if ( ${InvSlot[${slotID}].Pack} && !${Window[${InvSlot[${slotID}].Pack.Name}].Open} ) /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup 
      /squelch /nomodkey /itemnotify ${oldSlotID} leftmouseup 
      /if ( ${Cursor.ID} ) { 
         /if ( !${Cursor.Name.Equal[${oldItem}]} ) /autoinventory 
         /goto :drop_item 
      } 
   } 
:close_pack 
   /if ( ${InvSlot[${oldSlotID}].Pack} && ${Window[${InvSlot[${oldSlotID}].Pack.Name}].Open} && ( ${Cursor.Name.Equal[${itemName}]} || ${FindItem[${itemName}].ID} ) ) { 
      /squelch /nomodkey /itemnotify ${InvSlot[${oldSlotID}].Pack} rightmouseup 
      /goto :close_pack 
   } 
   /if ( ${InvSlot[${slotID}].Pack} && ${Window[${InvSlot[${slotID}].Pack.Name}].Open} && ( ${Cursor.Name.Equal[${itemName}]} || ${FindItem[${itemName}].ID} ) ) { 
      /squelch /nomodkey /itemnotify ${InvSlot[${slotID}].Pack} rightmouseup 
      /goto :close_pack 
   } 
/return

Sub WaitCast(mySub) 
/declare currentTarget int local ${Target.ID} 
/declare currentTargetType string local ${Target.Type} 
:wait_cast_loop 
/if (${Bool[${mySub}]}) /call ${mySub} 
/if (${Me.Casting.ID}) { 
/if (${currentTarget} && !${Spawn[${currentTarget}].Type.Equal[${currentTargetType}]}) { 
/if (!${Me.Casting.TargetType.Equal[PB AE]} && !${Me.Casting.TargetType.Equal[self]} && !${moveBack} && (!${Me.Mount.ID} || !${noInterrupt})) { 
/if (!${Me.Mount.ID} || ${castEndTime}>70) { 
/call Interrupt 
} else /if (${Me.Casting.RecastTime}>3) { 
/varset castReturn CAST_CANCELLED 
/keypress forward hold 
/delay 6 
/keypress forward 
/varset moveBack true 
} 
} 
} 
/if (${Me.State.Equal[DUCK]}) /varset castReturn CAST_CANCELLED 
/goto :wait_cast_loop 
} 
/return 

Sub Event_BeginCast 
/if (${Defined[castReturn]}) /varset castReturn CAST_SUCCESS 
/return 

Sub Event_Collapse 
/if (${Defined[castReturn]}) /varset castReturn CAST_COLLAPSE 
/varset giveUpTimer 200 
/return 

Sub Event_FDFail(line,name) 
/if (${name.Equal[${Me.Name}]} && ${Defined[castReturn]}) { 
/if (!${Me.Standing}) /stand 
/varset castReturn CAST_RESTART 
} 
/return 

Sub Event_Fizzle 
/if (${Defined[castReturn]}) /varset castReturn CAST_FIZZLE 
/return 

Sub Event_Immune 
/if (${Defined[castReturn]}) /varset castReturn CAST_IMMUNE 
/return 

Sub Event_Interrupt 
/if (${Defined[castReturn]}) /varset castReturn CAST_INTERRUPTED 
/return 

Sub Event_NoHold 
/if (${Defined[spellNotHold]}) /varset spellNotHold 1 
/return 

Sub Event_NoLOS 
/if (${Defined[castReturn]}) /varset castReturn CAST_CANNOTSEE 
/return 

Sub Event_NoTarget 
/if (${Defined[castReturn]}) /varset castReturn CAST_NOTARGET 
/return 

Sub Event_NotReady 
/if (${Defined[castReturn]}) /varset castReturn CAST_NOTREADY 
/return 

Sub Event_OutOfMana 
/if (${Defined[castReturn]}) /varset castReturn CAST_OUTOFMANA 
/return 

Sub Event_OutOfRange 
/if (${Defined[castReturn]}) /varset castReturn CAST_OUTOFRANGE 
/return 

Sub Event_Recover 
/if (${Defined[castReturn]}) /varset castReturn CAST_RECOVER 
/return 

Sub Event_Resisted(line,name) 
/if (${selfResist} && ${name.Equal[${selfResistSpell}]}) /varset selfResist 0 
/if (${ResistCounter}) /varcalc ResistCounter ${ResistCounter}-1 
/if (${Defined[castReturn]}) /varset castReturn CAST_RESISTED 
/return 

Sub Event_Resisted2(line,name) 
/if (${Defined[selfResist]}) { 
/varset selfResist 1 
/varset selfResistSpell ${name} 
} 
/return 

Sub Event_Standing 
/stand 
/if (${Defined[castReturn]}) /varset castReturn CAST_RESTART 
/return 

Sub Event_Stunned 
/if (${Me.Stunned}) { 
/delay 3s !${Me.Stunned} 
} else { 
/delay 7 
} 
/if (${Defined[castReturn]}) /varset castReturn CAST_STUNNED 
/return